package com.wanqing.community.util;

import java.text.DecimalFormat;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 数字处理的辅助类
 */
public class NumberDealTools {

	/**
	 * 把一个数字类型的对象转为float形
	 * @param obj
	 * @return
	 */
	public static float objectTofloat(Object obj) {
		if (null == obj) {
			return 0f;
		} else {
			return Float.valueOf(obj.toString());
		}
	}

	/**
	 * 比较转INT
	 * 
	 * @param temobj
	 * @param obj
	 * @return
	 */
	public static int objectToInt(Object temobj, Object obj) {
		if (null == obj) {
			return objectToInt(temobj);
		} else {
			return objectToInt(obj);
		}
	}
	/**
	 * <p>Description:将Object转为Integer<p>
	 * <p>modifiContent:<p>
	 * @param obj
	 * @return
	 */
	public static Integer objectToInteger(Object obj){
		if(null==obj){
			return null;
		}
		String temp = String.valueOf(obj);
		if(StringTools.isEmptyOrNull(temp)){
			return null;
		}
		return Integer.valueOf(temp);
	}
	
	/**
	 * <p>Description:将Object转为Long<p>
	 * <p>modifiContent:<p>
	 * @param obj
	 * @return
	 */
	public static Long objectToLong(Object obj){
		if(null==obj){
			return null;
		}
		String temp = String.valueOf(obj);
		if(StringTools.isEmptyOrNull(temp)){
			return null;
		}
		return Long.valueOf(temp);
	}
	
	/**
	 * <p>Description:将Object转为Double<p>
	 * <p>modifiContent:<p>
	 * @param obj
	 * @return
	 */
	public static Double objectToDouble(Object obj){
		if(null==obj){
			return null;
		}
		String temp = String.valueOf(obj);
		if(StringTools.isEmptyOrNull(temp)){
			return null;
		}
		return Double.valueOf(temp);
	}
	
	/**
	 * <p>Description:将Object转为Float<p>
	 * <p>modifiContent:<p>
	 * @param obj
	 * @return
	 */
	public static Float objectToFloat(Object obj){
		if(null==obj){
			return null;
		}
		String temp = String.valueOf(obj);
		if(StringTools.isEmptyOrNull(temp)){
			return null;
		}
		return Float.valueOf(temp);
	}

	/**
	 * 把一个数字类型的对象转为int形
	 * 
	 * @param obj
	 * @return
	 */
	public static int objectToInt(Object obj) {
		if (null == obj) {
			return 0;
		} else {
			return Integer.parseInt(obj.toString());
		}
	}

	/**
	 * 把一个数字类型的对象转为double形
	 * 
	 * @param obj
	 * @return
	 */
	public static double objectTodouble(Object obj) {
		if (null == obj) {
			return 0d;
		} else {
			return Double.parseDouble(obj.toString());
		}
	}

	/**
	 * double 转为int
	 * 
	 * @param source
	 * @return
	 */
	public static int doubleToInt(double source) {
		Double db = new Double(source);
		return db.intValue();
	}
	
	/**
	 * <p>Description:将Object转基本数据类型long<p>
	 * <p>modifiContent:<p>
	 * @param obj
	 * @return
	 */
	public static long objectTolong(Object obj){
		if(null==obj){
			return 0l;
		}else{
			return Long.valueOf(obj.toString());
		}
	}

	/**
	 * 计算一个float类型数的百分比值
	 * 
	 * @param source
	 * @returnf float
	 */
	public static float percent(float source) {
		Double target = source * (Math.pow(100, -1));
		return Float.parseFloat(target.toString());
	}

	/**
	 * 计算一个double类型数的百分比值
	 * @param sourceDouble
	 * @return
	 */
	public static double percent(double sourceDouble) {
		return sourceDouble * (Math.pow(100, -1));
	}

	/**
	 * 计算一个float类型数的百分比值
	 * 
	 * @param source
	 * @returnf float
	 */
	public static float percent(String source) {
		float targets = stringTranceFloat(source);
		Double target = targets * (Math.pow(100, -1));
		return Float.parseFloat(target.toString());
	}

	/**
	 * 把一个字符串转成Float类型 1、如果为空则返回-1 2、如果sourceString含有字母则返回-2
	 * 
	 * @param sourceString
	 * @return
	 */
	public static float stringTranceFloat(String sourceString) {
		if (null == sourceString || "".equals(sourceString.trim())) {
			return 0f;
		} else {
			float temp = 0f;
			try {
				temp = Float.parseFloat(sourceString.trim());
			} catch (NumberFormatException e) {
				temp = -2f;
			}
			return temp;
		}

	}

	/**
	 * 把一个字符串转成Double类型 1、如果为空则返回-1 2、如果sourceString含有字母则返回-2
	 * 
	 * @param sourceString
	 * @return
	 */
	public static double stringTranceDouble(String sourceString) {
		if (StringTools.isEmptyOrNull(sourceString)) {
			return 0d;
		} else {
			double temp = 0;
			try {
				temp = Double.parseDouble(sourceString.trim());
			} catch (NumberFormatException e) {
				temp = -1d;
			}
			return temp;
		}
	}

	/**
	 * 计算以targetFloat为底的值
	 * 
	 * @param targetFloat
	 * @return
	 */
	public static float myPow(float targetFloat) {
		if (targetFloat == 0f) {
			return -1f;
		} else {
			Double b = Math.pow(targetFloat, -1);
			return Float.parseFloat(b.toString());
		}
	}

	/**
	 * 计算以targetDouble为底的值
	 * 
	 * @param targetDouble
	 * @return
	 */
	public static double myPow(double targetDouble) {
		if (targetDouble == 0) {
			return -1;
		} else {
			return Math.pow(targetDouble, -1);
		}
	}

	/**
	 * 验证非负整数
	 * 
	 * @param source
	 * @return
	 */
	public static boolean checkInt(String source) {
		boolean flag = false;
		if (!StringTools.isEmptyOrNull(source)) {
			String regex = "^[1-9]\\d*|0$";
			Pattern p = Pattern.compile(regex);
			Matcher m = p.matcher(source.trim());
			flag = m.matches();
		}
		return flag;
	}

	/**
	 * 字符串转为int型
	 * 
	 * @param sourceString
	 * @return int
	 */
	public static int stringTranceInt(String sourceString) {
		if (StringTools.isEmptyOrNull(sourceString)) {
			return 0;
		} else {
			try {
				return Integer.parseInt(sourceString.trim());
			} catch (NumberFormatException e) {
				return -2;
			}
		}
	}
	
	/**
	 * 字符串转为int型
	 * 
	 * @param sourceString
	 * @return int
	 */
	public static int stringTranceInt(String sourceString,int defaultValue) {
		if (StringTools.isEmptyOrNull(sourceString)) {
			return defaultValue;
		} else {
			try {
				return Integer.parseInt(sourceString.trim());
			} catch (NumberFormatException e) {
				return -2;
			}
		}
	}

	/**
	 * 字符串转为long型
	 * 
	 * @param sourceString
	 * @return
	 */
	public static long stringTranceLong(String sourceString) {
		if (null == sourceString || "".equals(sourceString.trim())) {
			return 0;
		} else {
			return Long.parseLong(sourceString.trim());
		}
	}

	/**
	 * 四舍五入
	 * 
	 * @param source
	 * @return
	 */
	public static int round(double source) {
		DecimalFormat df = new DecimalFormat("#");
		return Integer.parseInt(df.format(source));
	}

	/**
	 * 格式 化两位小数第三位隔开
	 * 
	 * @param source
	 * @return
	 */
	public static String decimal(double source) {
		DecimalFormat df = new DecimalFormat("#,##0.00");
		return df.format(source);
	}

	/**
	 * 格式 化三位小数
	 * 
	 * @param source
	 * @return
	 */
	public static String decimalThree(double source) {
		DecimalFormat df = new DecimalFormat("##0.000");
		return df.format(source);
	}

	/**
	 * 格式 化两位小数
	 * 
	 * @param source
	 * @return
	 */
	public static String decimalTwo(double source) {
		DecimalFormat df = new DecimalFormat("##0.00");
		return df.format(source);
	}

	public static String decimalToOne(double source) {
		DecimalFormat df = new DecimalFormat("##0.0");
		return df.format(source);
	}

	/**
	 * 格式 化4位小数
	 * 
	 * @param source
	 * @return
	 */
	public static String decimalFour(double source) {
		DecimalFormat df = new DecimalFormat("##0.0000");
		return df.format(source);
	}
	
	/**
	 * 格式 化5位小数
	 * 
	 * @param source
	 * @return
	 */
	public static String decimalFive(double source) {
		DecimalFormat df = new DecimalFormat("##0.00000");
		return df.format(source);
	}

	public static String decimalTwo(float source) {
		double temp = new Float(source).doubleValue();
		return decimalTwo(temp);
	}

	/**
	 * 格式 化4位小数
	 * 
	 * @param source
	 * @return
	 */
	public static String decimalFour(float source) {
		double temp = new Float(source).doubleValue();
		return decimalFour(temp);
	}

	/**
	 * 格式化成整型每三位隔开
	 * 
	 * @param source
	 * @return
	 */
	public static String decimalOne(double source) {
		DecimalFormat df = new DecimalFormat("#,##0.##");
		return df.format(source);
	}

	/**
	 * 格式化成整型
	 * 
	 * @param source
	 * @return
	 */
	public static String decimalOne1(double source) {
		DecimalFormat df = new DecimalFormat("##0.##");
		return df.format(source);
	}

	/**
	 * doublel转String
	 * 
	 * @param source
	 * @return
	 */
	public static String doubleString(double source) {
		return decimal(source);
	}

	/**
	 * @param a
	 * @return 格式化double型,为两位小位
	 */
	public static double decimala(double a) {
		DecimalFormat format = new DecimalFormat("#0.0000");
		return Double.valueOf(format.format(a));
	}

	/**
	 * 判断是否为浮点数，包括double和float
	 * 
	 * @param str
	 *            传入的字符串
	 * @return 是浮点数返回true,否则返回false
	 */
	public static boolean isDouble(String str) {
		if (null == str || "".equals(str.trim()) || "null".equals(str.trim())) {
			return false;
		} else {
			String regex = "^[-\\+]?[.\\d]*$";
			Pattern p = Pattern.compile(regex);
			Matcher m = p.matcher(str.trim());
			return m.matches();
		}
	}

	/**
	 * 截取小数位数，不进行四舍五入，剩下的小数直接舍去
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @param decimals
	 *            需要截取的小数位数
	 * @return
	 */
	// public static double truncateDecimal(double value, int decimals){
	// double decimalsDouble = Math.pow(10, decimals);
	// return ((int)Math.floor(value*decimalsDouble))/decimalsDouble;
	// }
	/**
	 * 截取小数位数，不进行四舍五入，剩下的小数直接舍去
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @param decimals
	 *            需要截取的小数位数
	 * @return
	 */
	// public static double truncateStrDecimal(String value, int decimals){
	// double decimalsDouble = Math.pow(10, decimals);
	// return
	// ((int)Math.floor(Double.valueOf(value)*decimalsDouble))/decimalsDouble;
	// }
	/**
	 * 截取2位小数，不进行四舍五入，剩下的小数直接舍去
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @return
	 */
	public static String truncate2Decimal(Double value) {
		if (value == null) {
			return "0.00";
		}
		// double temp = ((long)Math.floor(value * 1000)) / 1000.0;
		// DecimalFormat df = new DecimalFormat("##0.00");
		// return df.format(temp);
		DecimalFormat format = new DecimalFormat("##0.000");
		String result = format.format(value);
		return result.substring(0, result.length() - 1);
	}

	/**
	 * 截取2位小数，不进行四舍五入，剩下的小数直接舍去
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @return
	 */
	public static String truncate2DecimalStr(String value) {
		if (StringTools.isEmptyOrNull(value)) {
			return "0.00";
		}
		// double temp = ((long)Math.floor(Double.valueOf(value) * 1000)) /
		// 1000.0;
		// DecimalFormat df = new DecimalFormat("##0.00");
		// return df.format(temp);
		DecimalFormat format = new DecimalFormat("##0.000");
		String result = format.format(Double.valueOf(value));
		return result.substring(0, result.length() - 1);
	}

	/**
	 * 截取4位小数，不进行四舍五入，剩下的小数直接舍去
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @return
	 */
	public static String truncate4Decimal(Double value) {
		if (value == null) {
			return "0.0000";
		}
		// double temp = ((long)Math.floor(value * 100000)) / 100000.0;
		// DecimalFormat df = new DecimalFormat("##0.0000");
		// return df.format(temp);
		DecimalFormat format = new DecimalFormat("##0.00000");
		String result = format.format(value);
		return result.substring(0, result.length() - 1);
	}

	/**
	 * 截取4位小数，不进行四舍五入，剩下的小数直接舍去
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @return
	 */
	public static String truncate4DecimalStr(String value) {
		if (StringTools.isEmptyOrNull(value)) {
			return "0.0000";
		}
		// double temp = ((long)Math.floor(Double.valueOf(value) * 100000)) /
		// 100000.0;
		// DecimalFormat df = new DecimalFormat("##0.0000");
		// return df.format(temp);
		DecimalFormat format = new DecimalFormat("##0.00000");
		String result = format.format(Double.valueOf(value));
		return result.substring(0, result.length() - 1);
	}

	/**
	 * 截取2位小数，不进行四舍五入，剩下的小数直接舍去,入参double,出参double
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @return double
	 */
	public static double truncate2DecimalDouble(double value) {
		/*
		 * double valueReturn = 0.00; double temp =
		 * ((long)Math.floor(Double.valueOf(value) * 1000)) / 1000.0;
		 * DecimalFormat df = new DecimalFormat("##0.00"); String valueString =
		 * df.format(temp); valueReturn = Double.parseDouble(valueString);
		 * return valueReturn;
		 */

		DecimalFormat format = new DecimalFormat("##0.000");
		String valueString = format.format(value);
		return Double.parseDouble(valueString.substring(0,
				valueString.length() - 1));
	}

	/**
	 * 截取4位小数，不进行四舍五入，剩下的小数直接舍去,入参double,出参double
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @return double
	 */
	public static double truncate4DecimalDouble(double value) {
		/*
		 * double valueReturn = 0.00; double temp =
		 * ((long)Math.floor(Double.valueOf(value) * 100000)) / 100000.0;
		 * DecimalFormat df = new DecimalFormat("##0.0000"); String valueString =
		 * df.format(temp); valueReturn = Double.parseDouble(valueString);
		 * return valueReturn;
		 */

		DecimalFormat format = new DecimalFormat("##0.00000");
		String valueString = format.format(value);
		return Double.parseDouble(valueString.substring(0,
				valueString.length() - 1));
	}

	/**
	 * 截取2位小数，不进行四舍五入，剩下的小数直接舍去,入参float,出参float
	 * 
	 * @param value
	 *            需要进行截取的数
	 * @return float
	 */
	public static float truncate2DecimalFloat(float value) {		

		DecimalFormat format = new DecimalFormat("##0.000");
		String valueString = format.format(value);
		return Float.parseFloat(valueString.substring(0,
				valueString.length() - 1));
	}

	public static int getPageCount(int total,int pageSize){
		int pagetotal = 1;
		if(total<=pageSize){
			pagetotal = 1;
		}else{
			if(total%pageSize==0){
				pagetotal = total/pageSize;
			}else{
				pagetotal = (total/pageSize)+1;
			}
		}		
		return pagetotal;
	}
	
	public static double changeDouble(String flag,double soure){
		if("0".equals(flag)){
			return soure*10000;
		}
		return soure;
	}
	
	/**
	 * 将整数val，以digit位数格式数 如001,1001类型
	 * @param val
	 * @param digit
	 * @return
	 */
	public static String format(int val,int digit){		
		return String.format("%0"+digit+"d", val);
	}
	
	/**
	 * <p>Description:取得数组中的最大值与是小值,方法返回一个长度为2的数组，第一个元素为最小值，第二个元素为最大值<p>
	 * <p>modifiContent:<p>
	 * @param numbers
	 * @return
	 */
	public static double[] getMaxAndMin(double[] numbers){
		double[] resutl = new double[2];
		double max = numbers[0]; 
		double min = numbers[0];
		int arrLen = numbers.length;
		for(int i = 0;i<arrLen;i++){
			if(numbers[i]>=max){
				max = numbers[i];
			}
			if(numbers[i]<=min){
				min = numbers[i];
			}
		}
		resutl[0] = min;
		resutl[1] = max;
		return resutl;
	}
	
	/**
	 * <p>Description:取得数组中的最大值与是小值,方法返回一个长度为2的数组，第一个元素为最小值，第二个元素为最大值<p>
	 * @param numbers
	 * @return
	 */
	public static int[] getMaxAndMin(int[] numbers){
		int[] resutl = new int[2];
		int max = numbers[0]; 
		int min = numbers[0];
		int arrLen = numbers.length;
		for(int i = 0;i<arrLen;i++){
			if(numbers[i]>=max){
				max = numbers[i];
			}
			if(numbers[i]<=min){
				min = numbers[i];
			}
		}
		resutl[0] = min;
		resutl[1] = max;
		return resutl;
	}
	
	public static Integer[] stringArrayToIntegerArray(String[] sources){
		if(null==sources || sources.length==0){
			return new Integer[]{};
		}
		int len = sources.length;
		Integer[] results = new Integer[len];
		for(int i = 0;i<len;i++){
			results[i] = objectToInteger(sources[i]);
		}
		return results;
	}
	
	public static double createRandom(int rand){
		int a = new Random().nextInt(rand);
		return new Integer(a).doubleValue();
	}
	
	
	
}
